export default {
    data () {
        return {
            title: '',
            modules: [],
            nodeList: []
        }
    },
    methods: {
        selectedNode (e) {
            alert(e[0].id)
        },
        // 查询当前节点
        searchEach (node, value) {
            // 获取节点数的深度
            let depth = this.getTreeDepth(node);
            let self = this;
            for (let i = 0; i < depth - 1; i++) {
                // 记录【删除不匹配搜索内容的叶子节点】操作的次数。
                // 如果这个变量记录的操作次数为0，表示树形结构中，所有的
                // 叶子节点(不包含只有根节点的情况)都匹配搜索内容。那么就没有必要再
                // 在循环体里面遍历树了.
                let spliceCounter = 0;
                console.log(depth)
                // 遍历树形结构
                this.traverseTree(node, n => {
                    if (self.isHasChildren(n)) {
                        let children = n.children;
                        let length = children.length;
                        // 找到不匹配搜索内容的叶子节点并删除。为了避免要删除的元素在数组中的索引改变，从后向前循环,
                        // 找到匹配的元素就删除。
                        for (let j = length - 1; j >= 0; j--) {
                            let e3 = children[j];
                            if (!self.isHasChildren(e3) && e3.title.indexOf(value) <= -1) {
                                children.splice(j, 1);
                                spliceCounter++;
                            } else {
                                this.nodeList[i].expand = true
                            }
                        }
                    }
                });

                // 所有的叶子节点都匹配搜索内容，没必要再执行循环体了。
                if (spliceCounter == 0) {
                    break;
                }
            }
        },

        search () {
            let self = this;
            // 把树形结构还原成搜索以前的。
            self.nodeList = self.modules
            if (!self.title) {
                // self.nodeList = self.modules
                return;
            }
            if (self.nodeList && self.nodeList.length > 0) {
                self.nodeList.forEach((n) => {
                    self.searchEach(n, self.title);
                });

                // 没有叶子节点的根节点也要清理掉
                /*
                let length = self.nodeList.length;
                for (let i = length - 1; i >= 0; i--) {
                    let e2 = self.nodeList[i];
                    if (!self.isHasChildren(e2) && e2.name.indexOf(self.title) <= -1) {
                        self.nodeList.splice(i, 1);
                    } else {
                        // self.nodeList[i].expand = true
                    }
                }
                */
            }
        },
        // 判断树形结构中的一个节点是否具有孩子节点
        isHasChildren (node) {
            let flag = false;
            if (node.children && node.children.length > 0) {
                flag = true;
            }
            return flag;
        },

        // 获取树的深度
        getTreeDepth (node) {
            if (undefined == node || null == node) {
                return 0;
            }
            let r = 0;
            // 树中当前层节点的集合。
            let currentLevelNodes = [node];
            while (currentLevelNodes.length > 0) {
                r++;
                let nextLevelNodes = new Array();
                for (let i = 0, len = currentLevelNodes.length; i < len; i++) {
                    let e = currentLevelNodes[i];
                    if (this.isHasChildren(e)) {
                        nextLevelNodes = nextLevelNodes.concat(e.children);
                    }
                }
                currentLevelNodes = nextLevelNodes;
            }
            return r;
        },

        // 非递归遍历树
        traverseTree (node, callback) {
            if (!node) {
                return;
            }
            var stack = [];
            stack.push(node);
            var tmpNode;
            while (stack.length > 0) {
                tmpNode = stack.pop();
                callback(tmpNode);
                if (tmpNode.children && tmpNode.children.length > 0) {
                    for (let i = tmpNode.children.length - 1; i >= 0; i--) {
                        stack.push(tmpNode.children[i]);
                    }
                }
            }
        }
    }
}